/**
 * 图片管理模块
 * 负责处理图片的选择、验证、转换和插入
 */

class ImageManager {
  constructor() {
    this.supportedFormats = ['image/jpeg', 'image/jpg', 'image/png', 'image/gif', 'image/webp', 'image/bmp'];
    this.maxFileSize = 5 * 1024 * 1024; // 5MB
    this.fileInput = null;
    this.createFileInput();
  }

  /**
   * 创建隐藏的文件输入元素
   */
  createFileInput() {
    this.fileInput = document.createElement('input');
    this.fileInput.type = 'file';
    this.fileInput.accept = 'image/*';
    this.fileInput.style.display = 'none';
    document.body.appendChild(this.fileInput);
  }

  /**
   * 选择图片文件
   * @returns {Promise<File>} 选中的图片文件
   */
  selectImage() {
    return new Promise((resolve, reject) => {
      // 清理之前的事件监听器
      this.fileInput.onchange = null;
      this.fileInput.oncancel = null;
      
      // 设置文件选择事件
      this.fileInput.onchange = (event) => {
        const file = event.target.files[0];
        if (file) {
          resolve(file);
        } else {
          reject(new Error('未选择文件'));
        }
        // 清空输入，允许重复选择同一文件
        this.fileInput.value = '';
      };

      // 处理用户取消选择（ESC键或关闭对话框）
      this.fileInput.oncancel = () => {
        reject(new Error('用户取消选择'));
        this.fileInput.value = '';
      };

      // 触发文件选择对话框
      this.fileInput.click();
    });
  }

  /**
   * 验证图片文件
   * @param {File} file 图片文件
   * @returns {Object} 验证结果对象 {isValid: boolean, error?: string}
   */
  validateImage(file) {
    // 检查文件类型
    if (!this.supportedFormats.includes(file.type)) {
      return {
        isValid: false,
        error: `不支持的图片格式: ${file.type}。支持的格式: ${this.supportedFormats.join(', ')}`
      };
    }

    // 检查文件大小
    if (file.size > this.maxFileSize) {
      const maxSizeMB = this.maxFileSize / (1024 * 1024);
      const fileSizeMB = (file.size / (1024 * 1024)).toFixed(2);
      return {
        isValid: false,
        error: `图片文件过大: ${fileSizeMB}MB。最大允许: ${maxSizeMB}MB`
      };
    }

    return { isValid: true };
  }

  /**
   * 将文件转换为Base64
   * @param {File} file 图片文件
   * @returns {Promise<string>} Base64字符串
   */
  fileToBase64(file) {
    return new Promise((resolve, reject) => {
      const reader = new FileReader();
      
      reader.onload = () => {
        resolve(reader.result);
      };
      
      reader.onerror = () => {
        reject(new Error('文件读取失败'));
      };
      
      reader.readAsDataURL(file);
    });
  }

  /**
   * 插入图片到编辑器
   * @param {Object} quillInstance - Quill编辑器实例
   * @param {string} imageUrl - 图片URL（Base64或普通URL）
   * @param {string} altText - 替代文本
   */
  insertImage(quillInstance, imageUrl, altText = '') {
    console.log('insertImage方法被调用');
    console.log('quillInstance:', quillInstance);
    console.log('imageUrl长度:', imageUrl ? imageUrl.length : 'null');
    console.log('altText:', altText);
    
    if (!quillInstance) {
      console.error('编辑器实例不存在');
      throw new Error('编辑器实例不存在');
    }

    try {
      // 获取当前光标位置
      const range = quillInstance.getSelection(true);
      const index = range ? range.index : quillInstance.getLength();
      
      console.log('当前光标位置:', index);
      console.log('编辑器长度:', quillInstance.getLength());

      // 插入图片
      console.log('开始插入图片...');
      quillInstance.insertEmbed(index, 'image', imageUrl);
      console.log('insertEmbed调用完成');
      
      // 强制刷新编辑器显示
      setTimeout(() => {
        console.log('强制刷新编辑器显示');
        quillInstance.update();
        
        // 验证图片是否真的插入了
        const contents = quillInstance.getContents();
        console.log('编辑器内容:', contents);
        
        // 检查DOM中是否有图片元素
        const editorElement = quillInstance.root;
        const images = editorElement.querySelectorAll('img');
        console.log('编辑器中的图片数量:', images.length);
        
        if (images.length > 0) {
          console.log('最新插入的图片:', images[images.length - 1]);
        }
      }, 100);
      
      // 如果有替代文本，可以在这里处理
      if (altText) {
        // Quill默认不支持alt属性，这里可以扩展
        console.log('图片替代文本:', altText);
      }

      // 将光标移动到图片后面
      quillInstance.setSelection(index + 1);
      console.log('光标移动到位置:', index + 1);
      
      console.log('图片插入成功');
    } catch (error) {
      console.error('插入图片时出错:', error);
      throw error;
    }
  }

  /**
   * 处理图片插入（从文件选择器）
   * @param {Object} quillInstance - Quill编辑器实例
   */
  async handleImageInsert(quillInstance) {
    try {
      // 选择图片文件
      const file = await this.selectImage();
      
      // 验证图片
      const validation = this.validateImage(file);
      if (!validation.isValid) {
        this.showError(validation.error);
        return;
      }
      
      // 转换为Base64
      const base64Url = await this.fileToBase64(file);
      
      // 插入到编辑器
      this.insertImage(quillInstance, base64Url, file.name);
      
      console.log('图片插入成功:', file.name);
    } catch (error) {
      console.error('图片插入失败:', error);
      // 只有在错误不是"用户取消选择"时才显示错误提示
      if (error.message !== '用户取消选择') {
        this.showError('图片插入失败: ' + error.message);
      }
    }
  }

  /**
   * 处理剪切板图片粘贴
   * @param {ClipboardEvent} event - 剪切板事件
   * @param {Object} quillInstance - Quill编辑器实例
   * @returns {Promise<boolean>} 是否成功处理了图片
   */
  async handleClipboardImage(event, quillInstance) {
    try {
      console.log('开始处理剪切板图片粘贴');
      
      const clipboardData = event.clipboardData || event.originalEvent?.clipboardData;
      if (!clipboardData) {
        console.log('没有剪切板数据');
        return false;
      }

      // 查找剪切板中的图片文件
      const imageFile = this.extractImageFromClipboard(clipboardData);
      if (!imageFile) {
        console.log('剪切板中没有图片文件');
        return false;
      }

      console.log('找到图片文件:', imageFile.name, imageFile.type, imageFile.size);

      // 阻止默认粘贴行为
      event.preventDefault();

      // 验证图片
      const validation = this.validateImage(imageFile);
      if (!validation.isValid) {
        console.error('图片验证失败:', validation.error);
        this.showError(validation.error);
        return true; // 返回true表示我们处理了这个事件，即使失败了
      }

      console.log('图片验证通过');

      // 转换为Base64
      const base64Url = await this.fileToBase64(imageFile);
      console.log('Base64转换完成，长度:', base64Url.length);
      
      // 检查Quill实例
      if (!quillInstance) {
        console.error('Quill实例不存在');
        this.showError('编辑器实例不存在');
        return true;
      }

      console.log('准备插入图片到编辑器');
      
      // 插入到编辑器
      this.insertImage(quillInstance, base64Url, `粘贴的图片_${Date.now()}`);
      
      console.log('剪切板图片插入成功');
      return true;
    } catch (error) {
      console.error('剪切板图片处理失败:', error);
      this.showError('剪切板图片处理失败: ' + error.message);
      return true; // 返回true表示我们处理了这个事件，即使失败了
    }
  }

  /**
   * 从剪切板数据中提取图片文件
   * @param {DataTransfer} clipboardData - 剪切板数据
   * @returns {File|null} 图片文件或null
   */
  extractImageFromClipboard(clipboardData) {
    const items = clipboardData.items;
    if (!items) {
      return null;
    }

    // 遍历剪切板项目，查找图片
    for (let i = 0; i < items.length; i++) {
      const item = items[i];
      
      // 检查是否为图片类型
      if (item.type && item.type.startsWith('image/')) {
        const file = item.getAsFile();
        if (file) {
          return file;
        }
      }
    }

    return null;
  }

  /**
   * 显示错误提示
   * @param {string} message 错误消息
   */
  showError(message) {
    // 创建简单的错误提示
    const errorDiv = document.createElement('div');
    errorDiv.style.cssText = `
      position: fixed;
      top: 20px;
      right: 20px;
      background: #ff4757;
      color: white;
      padding: 12px 20px;
      border-radius: 4px;
      box-shadow: 0 2px 10px rgba(0,0,0,0.1);
      z-index: 10000;
      font-size: 14px;
      max-width: 300px;
    `;
    errorDiv.textContent = message;
    
    document.body.appendChild(errorDiv);
    
    // 3秒后自动移除
    setTimeout(() => {
      if (errorDiv.parentNode) {
        errorDiv.parentNode.removeChild(errorDiv);
      }
    }, 3000);
  }

  /**
   * 设置最大文件大小
   * @param {number} sizeInBytes 文件大小（字节）
   */
  setMaxFileSize(sizeInBytes) {
    this.maxFileSize = sizeInBytes;
  }

  /**
   * 设置支持的图片格式
   * @param {Array<string>} formats 支持的MIME类型数组
   */
  setSupportedFormats(formats) {
    this.supportedFormats = formats;
  }

  /**
   * 销毁实例，清理资源
   */
  destroy() {
    if (this.fileInput && this.fileInput.parentNode) {
      this.fileInput.parentNode.removeChild(this.fileInput);
    }
    this.fileInput = null;
  }
}

export default ImageManager;